home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 17 / CU Amiga Magazine's Super CD-ROM 17 (1997)(EMAP Images)(GB)[!][issue 1997-12].iso / CUCD / Programming / DiceSource / src / dc1 / save / protos.h < prev    next >
Encoding:
Text File  |  1993-02-03  |  19.9 KB  |  554 lines
  1.  
  2. /* MACHINE GENERATED */
  3.  
  4.  
  5. /* asm1.c               */
  6.  
  7. Prototype long AsmState;
  8. Prototype long LabelReturn;
  9. Prototype long LabelProfBeg;
  10. Prototype long LabelProfEnd;
  11. Prototype long LabelRegsUsed;
  12. Prototype long RegReserved;
  13. Prototype char LastSectBuf[256];
  14. Prototype char *LastSectName;
  15. Prototype char *SegNames[];
  16. Prototype char *SegTypes[];
  17. Prototype short OutAlign;
  18. Prototype void asm_extern(Var *);
  19. Prototype void asm_export(Symbol *);
  20. Prototype void asm_procbegin(Var *);
  21. Prototype void asm_regentry(Var *);
  22. Prototype void asm_proclink(Var *);
  23. Prototype void asm_procend(Var *, short);
  24. Prototype void asm_returnstorage(Exp *);
  25. Prototype void asm_dynamictag(Var *);    /* XXX */
  26. Prototype void asm_segment(Var *);
  27. Prototype void asm_align(long);
  28. Prototype void asm_ds(Symbol *, long);
  29. Prototype void asm_string(long, ubyte *, long, long, long);
  30. Prototype void asm_label(long);
  31. Prototype void asm_branch(long);
  32. Prototype void asm_condbra(short, long);
  33. Prototype long asm_push(Exp *, Type *, Stor *);
  34. Prototype void asm_push_mask(long);
  35. Prototype long asm_stackbytes(Type *);
  36. Prototype void asm_call(Exp *, Stor *, Type *, Stor *, long, short);
  37. Prototype void asm_pop(long);
  38. Prototype void asm_pop_mask(long);
  39. Prototype void asm_ext(Exp *, Stor *, Stor *, long);
  40. Prototype void asm_test(Exp *, Stor *);
  41. Prototype void asm_test_scc(Exp *, long, Stor *, short, Stor *);
  42. Prototype void asm_cond_scc(Exp *, long, Stor *, Stor *, short *, Stor *);
  43. Prototype void asm_sccb(Exp *, Stor *, short, short);
  44. Prototype void asm_clr(Exp *, Stor *);
  45. Prototype void asm_movei(Exp *, long, Stor *);
  46. Prototype void asm_neg(Exp *, Stor *, Stor *);
  47. Prototype void ThreeOp(Exp *, Stor *, Stor *, Stor *, void (*)(Exp *, Stor *, Stor *, Stor *));
  48. Prototype void asm_add(Exp *, Stor *, Stor *, Stor *);
  49. Prototype void asm_sub(Exp *, Stor *, Stor *, Stor *);
  50. Prototype void asm_xor(Exp *, Stor *, Stor *, Stor *);
  51. Prototype void asm_and(Exp *, Stor *, Stor *, Stor *);
  52. Prototype void asm_or(Exp *, Stor *, Stor *, Stor *);
  53. Prototype void asm_test_and(Exp *, Stor *, Stor *);
  54. Prototype void asm_switch(Exp *, long, long *, long *, long);
  55. Prototype long SizeFit(long);
  56. Prototype long SizeFitSU(long, Stor *);
  57. Prototype void asm_end(void);
  58. Prototype long asm_rcomove(Exp *, char *, short, Stor *);
  59. Prototype void asm_exg(Stor *, Stor *);
  60. Prototype long RegCallOrder(Type *, char *, char *);
  61. Prototype void AutoAssignRegisteredArgs(Var **, short);
  62.  
  63. /* asm2.c               */
  64.  
  65. Prototype void asm_move(Exp *, Stor *, Stor *);
  66. Prototype void asm_move_cast(Exp *, Stor *, Stor *);
  67. Prototype long ReverseOrder(short);
  68. Prototype void asm_cmp(Exp *, Stor *, Stor *, short *);
  69. Prototype long asm_div(Exp *, Stor *, Stor *, Stor *, short);
  70. Prototype long asm_mul(Exp *, Stor *, Stor *, Stor *);
  71. Prototype long asm_mul_requires_call(long);
  72. Prototype void asm_shift(Exp *, long, Stor *, Stor *, Stor *);
  73. Prototype void CallAsmSupport(Exp *, char *, Stor *, Stor *, Stor *, short);
  74. Prototype void asm_bfext(Exp *, Stor *, Stor *);
  75. Prototype void asm_bfsto(Exp *, Stor *, Stor *);
  76. Prototype void asm_bftst(Exp *, Stor *);
  77. Prototype void asm_blockfill(Exp *, Stor *, long, char);
  78. Prototype void asm_illegal(void);
  79. Prototype void asm_moveqAndSwap(long, char, short);
  80.  
  81. /* asmaddr.c            */
  82.  
  83. Prototype void asm_getindex(Exp *, Type *, Stor *, Stor *, long, Stor *, short, short);
  84. Prototype void asm_getind(Exp *, Type *, Stor *, Stor *, short, short, short);
  85. Prototype void asm_getlea(Exp *, Stor *, Stor *);
  86. Prototype void asm_lea(Exp *, Stor *, long, Stor *);
  87.  
  88. /* asmflt.c             */
  89.  
  90. Prototype void asm_fpadd(Exp *, Type *, Stor *, Stor *, Stor *);
  91. Prototype void asm_fpsub(Exp *, Type *, Stor *, Stor *, Stor *);
  92. Prototype void asm_fpmul(Exp *, Type *, Stor *, Stor *, Stor *);
  93. Prototype void asm_fpdiv(Exp *, Type *, Stor *, Stor *, Stor *);
  94. Prototype void asm_fpneg(Exp *, Type *, Stor *, Stor *);
  95. Prototype void asm_fpcmp(Exp *, Stor *, Stor *, short *);
  96. Prototype void asm_fptest(Exp *, Stor *);
  97. Prototype void asm_fptoint(Exp *, Stor *, Stor *);
  98. Prototype void asm_inttofp(Exp *, Stor *, Stor *);
  99. Prototype void asm_fptofp(Exp *, Stor *, Stor *);
  100. Prototype void asm_fltconst(Exp *, Stor *, long *);
  101. Prototype void CallFPSupport(Exp *, long, Stor *, Stor *, Stor *, char *, short);
  102. Prototype void asm_layoutfpconst(Exp *, Stor *, Stor *);
  103. Prototype void ConstFpNeg(Exp *, Stor *, Stor *);
  104. Prototype void ConstFpAdd(Exp *, Stor *, Stor *, Stor *);
  105. Prototype void ConstFpSub(Exp *, Stor *, Stor *, Stor *);
  106. Prototype void ConstFpMul(Exp *, Stor *, Stor *, Stor *);
  107. Prototype void ConstFpDiv(Exp *, Stor *, Stor *, Stor *);
  108. Prototype void CloseLibsExit();
  109.  
  110. /* asubs.c              */
  111.  
  112. Prototype char SizC[];
  113. Prototype char StorBuf[2][1024];
  114. Prototype char *RegMaskToString(long, short *);
  115. Prototype char *StorToString(Stor *, short *);
  116. Prototype char *StorToStringBuf(Stor *, char *);
  117. Prototype long SameStorage(Stor *, Stor *);
  118. Prototype long SameRegister(Stor *, Stor *);
  119. Prototype long RegisterMaskConflict(Stor *, ulong);
  120. Prototype long ImmStorage(Stor *);
  121. Prototype void outop(char *, short, Stor *, Stor *);
  122. Prototype void GenStaticData(Var *);
  123. Prototype void GenDataElm(Exp *, Type *);
  124. Prototype char *itohex(char *, ulong);
  125. Prototype char *itodec(char *, ulong);
  126. Prototype void AutoAggregateBeg(Stor *, Type *);
  127. Prototype void AutoAggregate(void *, long);
  128. Prototype void AutoAggregateEnd(void);
  129. Prototype void AutoAggregateSync(void);
  130.  
  131. /* block.c              */
  132.  
  133. Prototype BlockStmt *CurGen;
  134. Prototype short BlockCost;
  135. Prototype BlockStmt *BlockDown(short);
  136. Prototype BlockStmt *BlockUp(void);
  137. Prototype Var *BlockAddVar(Var *);
  138. Prototype void BlockAddStmt(Stmt *);
  139. Prototype void BlockFlagCallMade(void);
  140. Prototype long FindContinueLabel(void);
  141. Prototype long FindBreakLabel(void);
  142. Prototype void GenPush(BlockStmt *);
  143. Prototype void GenFlagCallMade(void);
  144. Prototype void GenPop(BlockStmt *);
  145. Prototype void BlockAddTop(Var *);
  146. Prototype Var *BlockRemoveDuplicateVar(long, Symbol *, Type *);
  147. Prototype int CompareTypes(Type *, Type *, short);
  148.  
  149. /* cexp.c               */
  150.  
  151. Prototype short CompExp(short, Exp **, long);
  152. Prototype short CompBracedAssign(short, Type *, Exp **, short, short);
  153.  
  154. /* exp.c                */
  155.  
  156. Prototype long ExpToConstant(Exp *);
  157. Prototype Type *ExpToType(Exp *);
  158. Prototype void ExpToLValue(Exp *, Stor *, Type *);
  159. Prototype void InsertCast(Exp **, Type *);
  160. Prototype void InsertNot(Exp **);
  161. Prototype void InsertBranch(Exp **, long, long);
  162. Prototype void InsertAssign(Exp **, Var *);
  163. Prototype long AutoIncDecSize(Exp *);
  164.  
  165. /* gen.c                */
  166.  
  167. Prototype Var *ProcVar;
  168. Prototype short GenPass;
  169. Prototype short ForceLinkFlag;
  170. Prototype short GenGlobal;  /*    global data gen for genass.c    */
  171. Prototype long AllocLabel(void);
  172. Prototype void InitGen(long);
  173. Prototype void GenerateVar(Var *);
  174. Prototype void GenBlock(BlockStmt *);
  175. Prototype void GenFor(ForStmt *);
  176. Prototype void GenWhile(WhileStmt *);
  177. Prototype void GenDo(DoStmt *);
  178. Prototype void GenIf(IfStmt *);
  179. Prototype void GenSwitch(SwitchStmt *);
  180. Prototype void GenBreak(BreakStmt *);
  181. Prototype void GenContinue(ContinueStmt *);
  182. Prototype void GenGoto(GotoStmt *);
  183. Prototype void GenLabel(LabelStmt *);
  184. Prototype void GenReturn(ReturnStmt *);
  185. Prototype void GenBreakPoint(BreakPointStmt *);
  186. Prototype void GenExp(ExpStmt *);
  187. Prototype void GenExpResult(ExpStmt *);
  188. Prototype int IsRegCall(long);
  189. Prototype void DebugLine(long);
  190.  
  191. /* genarith.c           */
  192.  
  193. Prototype void GenDiv(Exp **);
  194. Prototype void GenPercent(Exp **);
  195. Prototype void GenStar(Exp **);
  196. Prototype void GenMi(Exp **);
  197. Prototype void GenPl(Exp **);
  198. Prototype void GenNeg(Exp **);
  199. Prototype void GenParen(Exp **);
  200. Prototype void GenComma(Exp **);
  201.  
  202. /* genass.c             */
  203.  
  204. Prototype void GenEq(Exp **);
  205. Prototype void GenBracEq(Exp **);
  206. Prototype void GenBracedAssign(Exp **);
  207. Prototype void GenPercentEq(Exp **);
  208. Prototype void GenAndEq(Exp **);
  209. Prototype void GenStarEq(Exp **);
  210. Prototype void GenMiEq(Exp **);
  211. Prototype void GenDivEq(Exp **);
  212. Prototype void GenLtLtEq(Exp **);
  213. Prototype void GenGtGtEq(Exp **);
  214. Prototype void GenPlEq(Exp **);
  215. Prototype void GenOrEq(Exp **);
  216. Prototype void GenCaratEq(Exp **);
  217. Prototype void GenAssEq(Exp **);
  218. Prototype void GenSpecialAssignment(Exp **, void (*)(Exp **));
  219.  
  220. /* genbool.c            */
  221.  
  222. Prototype void BoolLabels(Exp *, long, long);
  223. Prototype void GenCondBranch(Exp **);
  224. Prototype void GenAndAnd(Exp **);
  225. Prototype void GenOrOr(Exp **);
  226. Prototype void GenBoolCompareSame(Exp **);
  227. Prototype void GenBoolCompare(Exp **);
  228. Prototype void GenNot(Exp **);
  229. Prototype void GenColon(Exp **);
  230. Prototype void GenQuestion(Exp **);
  231.  
  232. /* genlogic.c           */
  233.  
  234. Prototype void GenAnd(Exp **);
  235. Prototype void GenOr(Exp **);
  236. Prototype void GenXor(Exp **);
  237. Prototype void GenLShf(Exp **);
  238. Prototype void GenRShf(Exp **);
  239. Prototype void GenCompl(Exp **);
  240.  
  241. /* genmisc.c            */
  242.  
  243. Prototype void GenCast(Exp **);
  244. Prototype void GenSizeof(Exp **);
  245. Prototype void GenAddr(Exp **);
  246. Prototype void GenInd(Exp **);
  247. Prototype void GenPreInc(Exp **);
  248. Prototype void GenPreDec(Exp **);
  249. Prototype void GenIntConst(Exp **);
  250. Prototype void GenStrConst(Exp **);
  251. Prototype void GenFltConst(Exp **);
  252. Prototype void GenVarRef(Exp **);
  253. Prototype void GenCall(Exp **);
  254. Prototype void GenCastArgs(Type *, Exp *, Exp **);
  255. Prototype void GenPosInc(Exp **);
  256. Prototype void GenPosDec(Exp **);
  257. Prototype void GenStructInd(Exp **);
  258. Prototype void GenStructElm(Exp **);
  259. Prototype void GenArray(Exp **);
  260. Prototype void GenBFExt(Exp **);
  261. Prototype void BitFieldResultExp(Exp *);
  262. Prototype void BitFieldResultType(Exp **, int);
  263.  
  264. /* lex.c                */
  265.  
  266. Prototype void InitLex(void);
  267. Prototype short LexSimpleToken(void);
  268. Prototype short LexLineFeed(void);
  269. Prototype short LexWhiteSpace(void);
  270. Prototype short LexTLex(void);
  271. Prototype short LexSymbol(void);
  272. Prototype short LexInteger(void);
  273. Prototype short LexDecimal(void);
  274. Prototype short LexCharConst(void);
  275. Prototype short LexString(void);
  276. Prototype short LexToken(void);
  277. Prototype short LexOctal(ubyte, long);
  278. Prototype short LexHex(ubyte, long);
  279. Prototype short LexFloating(long, long);
  280. Prototype void PushLexFile(char *, short, long, long);
  281. Prototype short PopLexFile(void);
  282. Prototype int SpecialChar(long *);
  283. Prototype long CharToNibble(short);
  284. Prototype short SkipToken(short, short);
  285. Prototype char *TokenToStr(short);
  286. Prototype long    FindLexFileLine(long, char **, long *, long *);
  287. Prototype short FindLexCharAt(long);
  288. Prototype long      LexIntConst;
  289. Prototype char      *LexStrConst;   /*  also flt constant   */
  290. Prototype long      LexStrLen;
  291. Prototype Symbol  *LexSym;
  292. Prototype void      *LexData;
  293. Prototype char      LexHackColon;
  294. Prototype char      LexUnsigned;
  295. Prototype char FileName[128];
  296. Prototype char SymbolSpace[256];
  297. Prototype long Depth;
  298. Prototype short ErrorInFileValid;
  299. Prototype   long    LexCacheHits;
  300. Prototype   long    LexCacheMisses;
  301. Prototype LexFileNode *LFBase;
  302. Prototype short (*LexDispatch[256])(void);
  303.  
  304. /* main.c               */
  305.  
  306. Prototype short MC68020Opt;
  307. Prototype short MC68881Opt;
  308. Prototype short State;
  309. Prototype short DDebug;
  310. Prototype short SmallCode;
  311. Prototype short SmallData;
  312. Prototype short ConstCode;
  313. Prototype short AbsData;
  314. Prototype short ResOpt;
  315. Prototype short PIOpt;
  316. Prototype short VerboseOpt;
  317. Prototype short ProtoOnlyOpt;
  318. Prototype short XOpt;
  319. Prototype short FFPOpt;
  320. Prototype short GenStackOpt;
  321. Prototype short GenLinkOpt;
  322. Prototype short RegCallOpt;
  323. Prototype short RegSpecOutputOpt;
  324. Prototype short ProfOpt;
  325. Prototype short ForkOpt;
  326. Prototype short UnixCommonOpt;
  327. Prototype short DebugOpt;
  328. Prototype short AsmOnlyOpt;
  329. Prototype short ErrorOpt;
  330. Prototype long    ZAllocs;
  331. Prototype long    TAllocs;
  332. Prototype long    ZChunks, ZAloneChunks;
  333. Prototype long    TChunks, TAloneChunks;
  334. Prototype long    SymAllocs;
  335. Prototype long    ExitCode;
  336. Prototype long    RetryCount;
  337. Prototype char    *OutFileName;
  338. Prototype char    *InFileName;
  339. Prototype Var    DummyDataVar;
  340. Prototype Var    DummyCodeVar;
  341. Prototype char    *ErrorFile;
  342. Prototype int main(int, char **);
  343. Prototype void help(void);
  344. Prototype void _Assert(const char *, long);
  345. Prototype void DumpStats(void);
  346. Prototype void ParseOpts(short, char **, short);
  347.  
  348. /* reg.c                */
  349.  
  350. Prototype   void    ResetRegAlloc(void);
  351. Prototype   void    AllocExternalStorage(Symbol *, Stor *, Type *, long);
  352. Prototype   void    AllocStaticStorage(Symbol *, Stor *, Type *, long);
  353. Prototype   void    AllocConstStor(Stor *, long, Type *);
  354. Prototype   void    AllocFltConstStor(Stor *, char *, long, Type *);
  355. Prototype   void    AllocStackStorage(Stor *, Type *, long);
  356. Prototype   void    FreeStackStorage(Stor *);
  357. Prototype   void    ReUseStackStorage(Stor *);
  358. Prototype   void    AllocArgsStorage(Stor *, Type *, int, long);
  359. Prototype   int     AllocRegVarStorageReq(Var *, short, long);
  360. Prototype   int     AllocRegVarStorage(Var *);
  361. Prototype   void    AllocTmpStorage(Stor *, Type *, Stor *);
  362. Prototype   void    ReuseStorage(Stor *, Stor *);
  363. Prototype   void    FreeStorage(Stor *);
  364. Prototype   int     AllocDataRegister(Stor *, long);
  365. Prototype   int     AllocDataRegisterAbs(Stor *, long, int);
  366. Prototype   int     AllocAddrRegister(Stor *);
  367. Prototype   int     AllocAddrRegisterAbs(Stor *, int);
  368. Prototype   void    FreeRegister(Stor *);    /*  single registers only */
  369. Prototype   void    LockStorage(Stor *);
  370. Prototype   void    UnlockStorage(Stor *);
  371. Prototype   void    RegDisableRegs(ulong);
  372. Prototype   void    RegEnableRegs(void);
  373. Prototype   void    UnscratchStorage(Exp *);
  374. Prototype   int     RegInUse(short);
  375. Prototype   int     AllocRegisterAbs(Stor *, short, short);
  376. Prototype   int     AttemptAllocRegisterAbs(Stor *, short, short);
  377. Prototype   ulong   GetAllocatedScratch(void);
  378. Prototype   ulong   GetLockedScratch(void);
  379. Prototype   ulong   GetUsedRegisters(void);
  380. Prototype   ulong   RegCallUseRegister(short);
  381. Prototype   int     TooManyRegs(void);
  382. Prototype   int     CountDRegOver(void);
  383. Prototype   int     CountARegOver(void);
  384. Prototype   void    asm_save_regs(ulong);
  385. Prototype   int     asm_restore_regs(ulong);
  386. Prototype   void    RegFlagTryAgain(void);
  387. Prototype   void    PushStackStorage(void);
  388. Prototype   void    PopStackStorage(void);
  389. Prototype ulong   RegAlloc;    /*  protos for debugging only    */
  390. Prototype ulong   RegLocked;
  391. Prototype ulong   RegUsed;
  392.  
  393. /* rules.c              */
  394.  
  395. Prototype   void BinaryRules(Exp *);
  396. Prototype   void BinaryArithRules(Exp *);
  397. Prototype   void BinaryLogicRules(Exp *);
  398. Prototype   void UnaryLogicRules(Exp *);
  399. Prototype   void UnaryRules(Exp *);
  400. Prototype   void UnaryArithRules(Exp *);
  401. Prototype   void ShiftRules(Exp *);
  402. Prototype   void AddRules(Exp *);
  403. Prototype   void SubRules(Exp *);
  404. Prototype   void FloatingRules(Exp *);
  405. Prototype   void AssignRules(Exp *);
  406. Prototype   void CompareRules(Exp *, int);
  407. Prototype   void MatchRules(Exp *);
  408. Prototype   void OptBinaryArithRules(Exp *);
  409. Prototype   void OptBinaryRules(Exp *);
  410. Prototype   int  CheckConversion(Exp *, Type *, Type *);
  411. Prototype   int  CreateBinaryResultStorage(Exp *, short);
  412. Prototype   int  CreateUnaryResultStorage(Exp *, short);
  413. Prototype   short   AutoResultStorage(Exp *);
  414.  
  415. /* sem.c                */
  416.  
  417. Prototype void SemanticLevelDown(void);
  418. Prototype void SemanticLevelUp(void);
  419. Prototype void SemanticAddTop(Symbol *, short, void *);
  420. Prototype void SemanticAddTopBlock(Symbol *, short, void *);
  421. Prototype void SemanticAdd(Symbol *, short, void *);
  422.  
  423. /* stmt.c               */
  424.  
  425. Prototype short CompProcedureArgDeclarators(short, Var ***, long *, long *);
  426. Prototype short CompProcedure(short, Var *);
  427. Prototype short CompStmtDeclExp(short, Stmt **, long);
  428. Prototype short CompBlock(short, Stmt **);
  429. Prototype short CompFor(short, Stmt **);
  430. Prototype short CompWhile(short, Stmt **);
  431. Prototype short CompDo(short, Stmt **);
  432. Prototype short CompIf(short, Stmt **);
  433. Prototype short CompSwitch(short, Stmt **);
  434. Prototype short CompBreak(short, Stmt **);
  435. Prototype short CompContinue(short, Stmt **);
  436. Prototype short CompGoto(short, Stmt **);
  437. Prototype short CompLabel(short, Stmt **);
  438. Prototype short CompReturn(short, Stmt **);
  439. Prototype short CompBreakPoint(short, Stmt **);
  440.  
  441. /* subs.c               */
  442.  
  443. Prototype long Align(long, long);
  444. Prototype long PowerOfTwo(ulong);
  445. Prototype void *zalloc(long);
  446. Prototype void *talloc(long);
  447. Prototype void tclear(void);
  448. Prototype void *zrealloc(void *, long, long, long);
  449. Prototype char *SymToString(Symbol *);
  450. Prototype char *TypeToString(Type *);
  451. Prototype char *TypeToProtoStr(Type *, short);
  452. Prototype void eprintf(short, const char *, ...);
  453. Prototype void veprintf(short, const char *, va_list);
  454. Prototype void AddAuxSub(char *);
  455. Prototype void DumpAuxSubs(void);
  456. Prototype void MarkAreaMunged(long, long);
  457. Prototype int  OffsetMunged(long);
  458. Prototype long FPStrToInt(Exp *, char *, int);
  459. Prototype char *IntToFPStr(long, long, long *);
  460. Prototype int FltIsZero(Exp *, char *, int);
  461. Prototype int FltIsNegative(char *, int);
  462. Prototype long FPrefix(Exp *, char *, int, char *);
  463. Prototype void StorToTmpFlt(Exp *, Stor *, TmpFlt *);
  464. Prototype void TmpFltToStor(Exp *, TmpFlt *, Stor *);
  465. Prototype void BalanceTmpFlt(TmpFlt *, TmpFlt *);
  466. Prototype void NormalizeTmpFlt(TmpFlt *);
  467. Prototype int  TmpFltMantDiv(uword *, short, uword);
  468. Prototype int  TmpFltMantMul(uword *, short, uword);
  469. Prototype long Internationalize(char *str, long size);
  470. Prototype int LoadLocaleDefs(char *file);
  471. Prototype void NoMem(void);
  472.  
  473. /* sym.c                */
  474.  
  475. Prototype void InitSym(int);
  476. Prototype Symbol *MakeSymbol(const char *, short, short, void *);
  477. Prototype Symbol *PragmaSymbol(char *, short);
  478. Prototype SemInfo *FindSymbolId(Symbol *, short);
  479. Prototype long hash(const ubyte *, short);
  480.  
  481. /* toplevel.c           */
  482.  
  483. Prototype short TopLevel(short);
  484. Prototype short CompDecl(short, Var **, long);
  485. Prototype short CompType(short, Type **, long *, long *);
  486. Prototype short CompVar(short, Type *, long, long, Var **);
  487. Prototype short CompTypeDeclarators(short, Type **, Symbol **, long);
  488. Prototype short CompStructType(short, Type **, long);
  489. Prototype short CompEnumType(short, Type **);
  490. Prototype short CompTypeofType(short, Type **);
  491. Prototype short ResolveStructUnionType(Type *);
  492. Prototype void AddExternList(Var *);
  493. Prototype void DumpExternList(long);
  494. Prototype void AddStrList(ubyte *, long, long, long);
  495. Prototype void MakeStringConst(long);
  496. Prototype void DelStrList(long);
  497. Prototype void DumpStrList(void);
  498.  
  499. /* types.c              */
  500.  
  501. Prototype long NumTypesAlloc;
  502. Prototype Type VoidType;
  503. Prototype Type CharType;
  504. Prototype Type ShortType;
  505. Prototype Type LongType;
  506. Prototype Type CharPtrType;
  507. Prototype Type CharAryType;
  508. Prototype Type VoidPtrType;
  509. Prototype Type LongPtrType;
  510. Prototype Type UCharType;
  511. Prototype Type UShortType;
  512. Prototype Type ULongType;
  513. Prototype Type FloatType;
  514. Prototype Type DoubleType;
  515. Prototype Type LongDoubleType;
  516. Prototype Type DefaultProcType;
  517. Prototype void InitTypes(int);
  518. Prototype void LooseTypeLink(Type *, Type *);
  519. Prototype void TypeLink(Type *, Type *);
  520. Prototype void TypeLinkEnd(Type *, Type *);
  521. Prototype Type *TypeToPtrType(Type *);
  522. Prototype Type *TypeToAryType(Type *, Exp *, long);
  523. Prototype Type *TypeToProcType(Type *, Var **, short, long);
  524. Prototype Type *TypeToQualdType(Type *, long);
  525. Prototype Type *FindStructUnionType(Symbol *, long);
  526. Prototype Symbol *FindStructUnionTag(Type *);
  527. Prototype long FindStructUnionElm(Type *, Exp *, int *);
  528. Prototype Type *MakeStructUnionType(Symbol *, long);
  529. Prototype void SetStructUnionType(Type *, Var **, long, long);
  530. Prototype Type *MakeBitfieldType(long, int);
  531. Prototype Type *FindEnumType(Symbol *);
  532. Prototype Type *MakeEnumType(Symbol *);
  533. Prototype void AddEnumIdent(Type *, Symbol *, long);
  534. Prototype Type *ActualReturnType(Stmt *, Type *, Type *);
  535. Prototype Type *ActualPassType(Type *, Type *, int);
  536. Prototype Type *ActualArgType(Type *);
  537. Prototype int SamePointerType(Type *, Type *);
  538. Prototype void GenerateRegSpecOutput(Var *);
  539.  
  540. /* error.c              */
  541.  
  542. Prototype void cerror(short, const char *, ...);
  543. Prototype void vcerror(long, short, const char *, va_list va, short);
  544. Prototype void zerror(short, ...);
  545. Prototype void yerror(long, short, ...);
  546. Prototype char *ObtainErrorString(short);
  547. Prototype void ExitError(short);
  548.  
  549. /* pragma.c             */
  550.  
  551. Prototype void ProcessLibCallPragma(char *, short);
  552. Prototype char *plcsym(char *, char **, short *);
  553. Prototype PragNode *TestPragmaCall(Var *, char *);
  554.